home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termUploadQueue.c < prev    next >
C/C++ Source or Header  |  1995-06-17  |  31KB  |  1,499 lines
  1. /*
  2. **    termUploadQueue.c
  3. **
  4. **    Upload queue user interface.
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LIST=1000,GAD_NAME,
  13.         GAD_ADD,GAD_REMOVE,GAD_CLEAR,GAD_HIDE,
  14.         GAD_ADD_FILES
  15.     };
  16.  
  17. enum    {    APP_ICON=1,APP_WINDOW=2 };
  18.  
  19. enum    {    TRANSFERMSG_GET_LIST=1,TRANSFERMSG_CHECK_LIST,
  20.         TRANSFERMSG_UPLOAD,TRANSFERMSG_TOGGLE_ICON
  21.     };
  22.  
  23. STATIC struct List    *TransferList;
  24. STATIC struct Node    *TransferNode;
  25. STATIC LONG         TransferOffset,
  26.              TransferCount,
  27.              TransferSignal;
  28. STATIC struct Process    *TransferProcess;
  29. STATIC struct MsgQueue    *TransferQueue;
  30.  
  31.     /* QueuePanel(struct Window *Window):
  32.      *
  33.      *    Create the user interface for the queue panel.
  34.      */
  35.  
  36. STATIC LayoutHandle *
  37. QueuePanel(struct Window *Window)
  38. {
  39.     LayoutHandle *Handle;
  40.  
  41.     TransferNode    = NULL;
  42.     TransferOffset    = -1;
  43.     TransferCount    = GetListSize(TransferList);
  44.  
  45.     if(Handle = LT_CreateHandleTags(Window ? Window -> WScreen : NULL,
  46.         LH_LocaleHook,    &LocaleHook,
  47.     TAG_DONE))
  48.     {
  49.         LT_New(Handle,
  50.             LA_Type,    VERTICAL_KIND,
  51.         TAG_DONE);
  52.         {
  53.             LT_New(Handle,
  54.                 LA_Type,    VERTICAL_KIND,
  55.             TAG_DONE);
  56.             {
  57.                 LT_New(Handle,
  58.                     LA_Type,    LISTVIEW_KIND,
  59.                     LA_LabelID,    MSG_UPLOADQUEUE_FILES_TO_UPLOAD_TXT,
  60.                     LA_LabelPlace,    PLACE_ABOVE,
  61.                     LA_Chars,    30,
  62.                     LA_Lines,    10,
  63.                     LA_ID,        GAD_LIST,
  64.                     LALV_CursorKey,    TRUE,
  65.                     LALV_MaxGrowY,    20,
  66.                     LALV_MaxGrowX,    50,
  67.                     LALV_ResizeX,    TRUE,
  68.                     LALV_ResizeY,    TRUE,
  69.                     GTLV_Labels,    TransferList,
  70.  
  71.                     Kick30 ? LALV_Link : TAG_IGNORE,NIL_LINK,
  72.                 TAG_DONE);
  73.  
  74.                 LT_New(Handle,
  75.                     LA_Type,    STRING_KIND,
  76.                     LA_ID,        GAD_NAME,
  77.                     GTST_MaxChars,    255,
  78.                     LAST_Picker,    TRUE,
  79.                 TAG_DONE);
  80.  
  81.                 LT_EndGroup(Handle);
  82.             }
  83.  
  84.             LT_New(Handle,
  85.                 LA_Type,    HORIZONTAL_KIND,
  86.                 LA_LabelID,    MSG_V36_0043,
  87.                 LA_SameSize,    TRUE,
  88.             TAG_DONE);
  89.             {
  90.                 LT_New(Handle,
  91.                     LA_Type,    BUTTON_KIND,
  92.                     LA_LabelID,    MSG_ADD_SEVERAL_FILES_TXT,
  93.                     LA_ID,        GAD_ADD_FILES,
  94.                 TAG_DONE);
  95.  
  96.                 LT_New(Handle,
  97.                     LA_Type,    BUTTON_KIND,
  98.                     LA_LabelID,    MSG_UPLOADQUEUE_ADD_TXT,
  99.                     LA_ID,        GAD_ADD,
  100.                 TAG_DONE);
  101.  
  102.                 LT_New(Handle,
  103.                     LA_Type,    BUTTON_KIND,
  104.                     LA_LabelID,    MSG_UPLOADQUEUE_REMOVE_TXT,
  105.                     LA_ID,        GAD_REMOVE,
  106.                     GA_Disabled,    TRUE,
  107.                 TAG_DONE);
  108.  
  109.                 LT_New(Handle,
  110.                     LA_Type,    BUTTON_KIND,
  111.                     LA_LabelID,    MSG_UPLOADQUEUE_CLEAR_TXT,
  112.                     LA_ID,        GAD_CLEAR,
  113.                     GA_Disabled,    !TransferCount,
  114.                 TAG_DONE);
  115.  
  116.                 LT_EndGroup(Handle);
  117.             }
  118.  
  119.             LT_New(Handle,
  120.                 LA_Type,    VERTICAL_KIND,
  121.             TAG_DONE);
  122.             {
  123.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  124.  
  125.                 LT_EndGroup(Handle);
  126.             }
  127.  
  128.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  129.                 LAGR_SameSize,    TRUE,
  130.             TAG_DONE);
  131.             {
  132.                 LT_New(Handle,
  133.                     LA_Type,    BUTTON_KIND,
  134.                     LA_LabelID,    MSG_UPLOADQUEUE_BINARY_UPLOAD_TXT,
  135.                     LA_ID,        UPLOAD_BINARY,
  136.                     LABT_ExtraFat,    TRUE,
  137.                     LABT_ReturnKey,    TRUE,
  138.                     GA_Disabled,    !TransferCount,
  139.                 TAG_DONE);
  140.  
  141.                 LT_New(Handle,
  142.                     LA_Type,    BUTTON_KIND,
  143.                     LA_LabelID,    MSG_UPLOADQUEUE_TEXT_UPLOAD_TXT,
  144.                     LA_ID,        UPLOAD_TEXT,
  145.                     GA_Disabled,    !TransferCount,
  146.                 TAG_DONE);
  147.  
  148.                 LT_New(Handle,
  149.                     LA_Type,    BUTTON_KIND,
  150.                     LA_LabelID,    MSG_UPLOADQUEUE_HIDE_TXT,
  151.                     LA_ID,        GAD_HIDE,
  152.                     LABT_EscKey,    TRUE,
  153.                 TAG_DONE);
  154.  
  155.                 LT_EndGroup(Handle);
  156.             }
  157.  
  158.             LT_EndGroup(Handle);
  159.         }
  160.  
  161.         if(LT_Layout(Handle,LocaleString(MSG_UPLOADQUEUE_FILE_UPLOAD_LIST_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  162.             WA_DepthGadget,        TRUE,
  163.             WA_CloseGadget,        TRUE,
  164.             WA_DragBar,        TRUE,
  165.             WA_RMBTrap,        TRUE,
  166.             WA_Activate,        TRUE,
  167.             LAWN_BelowMouse,    TRUE,
  168.         TAG_DONE))
  169.         {
  170.             GuideContext(CONTEXT_UPLOAD_QUEUE);
  171.  
  172.             return(Handle);
  173.         }
  174.  
  175.         LT_DeleteHandle(Handle);
  176.     }
  177.  
  178.     return(NULL);
  179. }
  180.  
  181.     /* HandleQueueWindow(LayoutHandle *Handle):
  182.      *
  183.      *    Process queue panel messages.
  184.      */
  185.  
  186. STATIC LONG __regargs
  187. HandleQueueWindow(LayoutHandle *Handle)
  188. {
  189.     struct IntuiMessage    *Message;
  190.     ULONG             MsgClass,
  191.                  MsgQualifier;
  192.     UWORD             MsgCode;
  193.     struct Gadget        *MsgGadget;
  194.  
  195.     struct Node        *Node;
  196.  
  197.     struct Window        *Window = Handle -> Window;
  198.     LONG             Result = 0;
  199.  
  200.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  201.                 *DummyChar;
  202.     struct FileRequester    *FileRequest;
  203.     struct TagItem         DimensionTags[5];
  204.  
  205.     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  206.     {
  207.         MsgClass    = Message -> Class;
  208.         MsgQualifier    = Message -> Qualifier;
  209.         MsgCode        = Message -> Code;
  210.         MsgGadget    = (struct Gadget *)Message -> IAddress;
  211.  
  212.         LT_ReplyIMsg(Message);
  213.  
  214.         if(MsgClass == IDCMP_CLOSEWINDOW)
  215.             Result = GAD_HIDE;
  216.  
  217.         if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_NAME)
  218.         {
  219.             LT_LockWindow(Window);
  220.  
  221.             SplitFileName(LT_GetString(Handle,GAD_NAME),&DummyChar,DummyBuffer);
  222.  
  223.             if(FileRequest = GetFile(Window,LocaleString(MSG_UPLOADQUEUE_SELECT_FILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),FALSE))
  224.             {
  225.                 LT_SetAttributes(Handle,GAD_NAME,
  226.                     GTST_String,    DummyBuffer,
  227.                 TAG_DONE);
  228.             }
  229.  
  230.             LT_UnlockWindow(Window);
  231.  
  232.             LT_Activate(Handle,GAD_NAME);
  233.         }
  234.  
  235.         if(MsgClass == IDCMP_GADGETUP)
  236.         {
  237.             switch(MsgGadget -> GadgetID)
  238.             {
  239.                 case GAD_ADD_FILES:
  240.  
  241.                     LT_LockWindow(Window);
  242.  
  243.                     if(!GetCurrentDirName(DummyBuffer,MAX_FILENAME_LENGTH))
  244.                         DummyBuffer[0] = 0;
  245.  
  246.                     if(FileRequest = AllocAslRequestTags(ASL_FileRequest,
  247.                         ASL_Window,    Window,
  248.                         ASL_Hail,    LocaleString(MSG_ADD_FILES_TITLE_TXT),
  249.                         ASL_FuncFlags,    FILF_MULTISELECT,
  250.                         ASL_OKText,    LocaleString(MSG_ADD_GAD),
  251.                         ASL_CancelText,    LocaleString(MSG_DONE_GAD),
  252.                         ASL_Dir,    DummyBuffer,
  253.                         ASLFR_TextAttr,    &UserFont,
  254.                     TAG_MORE,GetDimensionTags(Window,DimensionTags)))
  255.                     {
  256.                         LONG i;
  257.  
  258.                         LT_SetAttributes(Handle,GAD_LIST,
  259.                             GTLV_Labels,    ~0,
  260.                         TAG_DONE);
  261.  
  262.                         while(AslRequestTags(FileRequest,TAG_DONE))
  263.                         {
  264.                             for(i = 0 ; i < FileRequest -> rf_NumArgs ; i++)
  265.                             {
  266.                                 if(FileRequest -> fr_ArgList[i] . wa_Lock)
  267.                                 {
  268.                                     if(!NameFromLock(FileRequest -> fr_ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  269.                                         DummyBuffer[0] = 0;
  270.                                 }
  271.                                 else
  272.                                     strcpy(DummyBuffer,FileRequest -> fr_Drawer);
  273.  
  274.                                 if(FileRequest -> fr_ArgList[i] . wa_Name)
  275.                                 {
  276.                                     if(!AddPart(DummyBuffer,FileRequest -> fr_ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  277.                                         DummyBuffer[0] = 0;
  278.                                 }
  279.  
  280.                                 if(DummyBuffer[0])
  281.                                 {
  282.                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  283.                                     {
  284.                                         Node -> ln_Name = (STRPTR)(Node + 1);
  285.  
  286.                                         strcpy(Node -> ln_Name,DummyBuffer);
  287.  
  288.                                         AddTail(TransferList,Node);
  289.  
  290.                                         TransferNode = Node;
  291.                                         TransferOffset = TransferCount++;
  292.                                     }
  293.                                 }
  294.                             }
  295.  
  296.                             LT_SetAttributes(Handle,GAD_LIST,
  297.                                 GTLV_Labels,    TransferList,
  298.                                 GTLV_Selected,    TransferOffset,
  299.                             TAG_DONE);
  300.                         }
  301.  
  302.                         LT_SetAttributes(Handle,GAD_LIST,
  303.                             GTLV_Labels,    TransferList,
  304.                             GTLV_Selected,    TransferOffset,
  305.                         TAG_DONE);
  306.  
  307.                         if(TransferCount)
  308.                         {
  309.                             LT_SetAttributes(Handle,GAD_NAME,
  310.                                 GTST_String,    "",
  311.                             TAG_DONE);
  312.  
  313.                             LT_SetAttributes(Handle,GAD_REMOVE,
  314.                                 GA_Disabled,    FALSE,
  315.                             TAG_DONE);
  316.  
  317.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  318.                                 GA_Disabled,    FALSE,
  319.                             TAG_DONE);
  320.  
  321.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  322.                                 GA_Disabled,    FALSE,
  323.                             TAG_DONE);
  324.  
  325.                             LT_SetAttributes(Handle,GAD_CLEAR,
  326.                                 GA_Disabled,    FALSE,
  327.                             TAG_DONE);
  328.                         }
  329.  
  330.                         PutDimensionTags(Window,FileRequest -> rf_LeftEdge,FileRequest -> rf_TopEdge,FileRequest -> rf_Width,FileRequest -> rf_Height);
  331.  
  332.                         FreeAslRequest(FileRequest);
  333.                     }
  334.  
  335.                     LT_UnlockWindow(Window);
  336.                     break;
  337.  
  338.                 case GAD_ADD:
  339.  
  340.                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  341.                     {
  342.                         Node -> ln_Name = (STRPTR)(Node + 1);
  343.  
  344.                         Node -> ln_Name[0] = 0;
  345.  
  346.                         LT_SetAttributes(Handle,GAD_LIST,
  347.                             GTLV_Labels,    ~0,
  348.                         TAG_DONE);
  349.  
  350.                         AddTail(TransferList,Node);
  351.  
  352.                         LT_SetAttributes(Handle,GAD_LIST,
  353.                             GTLV_Labels,    TransferList,
  354.                             GTLV_Selected,    TransferOffset = TransferCount++,
  355.                         TAG_DONE);
  356.  
  357.                         LT_SetAttributes(Handle,GAD_NAME,
  358.                             GTST_String,    "",
  359.                         TAG_DONE);
  360.  
  361.                         LT_SetAttributes(Handle,GAD_REMOVE,
  362.                             GA_Disabled,    FALSE,
  363.                         TAG_DONE);
  364.  
  365.                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  366.                             GA_Disabled,    FALSE,
  367.                         TAG_DONE);
  368.  
  369.                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  370.                             GA_Disabled,    FALSE,
  371.                         TAG_DONE);
  372.  
  373.                         LT_SetAttributes(Handle,GAD_CLEAR,
  374.                             GA_Disabled,    FALSE,
  375.                         TAG_DONE);
  376.  
  377.                         TransferNode = Node;
  378.  
  379.                         LT_Activate(Handle,GAD_NAME);
  380.                     }
  381.                     else
  382.                         DisplayBeep(Window -> WScreen);
  383.  
  384.                     break;
  385.  
  386.                 case GAD_REMOVE:
  387.  
  388.                     if(TransferNode)
  389.                     {
  390.                         LT_SetAttributes(Handle,GAD_LIST,
  391.                             GTLV_Labels,    ~0,
  392.                         TAG_DONE);
  393.  
  394.                         if(--TransferCount)
  395.                         {
  396.                             if(TransferNode -> ln_Succ -> ln_Succ)
  397.                                 Node = TransferNode -> ln_Succ;
  398.                             else
  399.                             {
  400.                                 if(TransferNode -> ln_Pred -> ln_Pred)
  401.                                 {
  402.                                     Node = TransferNode -> ln_Pred;
  403.  
  404.                                     TransferOffset--;
  405.                                 }
  406.                                 else
  407.                                 {
  408.                                     TransferOffset = -1;
  409.  
  410.                                     Node = NULL;
  411.                                 }
  412.                             }
  413.                         }
  414.                         else
  415.                         {
  416.                             TransferOffset = -1;
  417.  
  418.                             Node = NULL;
  419.                         }
  420.  
  421.                         Remove(TransferNode);
  422.  
  423.                         FreeVecPooled(TransferNode);
  424.  
  425.                         TransferNode = Node;
  426.  
  427.                         LT_SetAttributes(Handle,GAD_LIST,
  428.                             GTLV_Labels,    TransferList,
  429.                             GTLV_Selected,    TransferOffset,
  430.                         TAG_DONE);
  431.  
  432.                         if(!TransferCount)
  433.                         {
  434.                             LT_SetAttributes(Handle,GAD_REMOVE,
  435.                                 GA_Disabled,    TRUE,
  436.                             TAG_DONE);
  437.  
  438.                             LT_SetAttributes(Handle,GAD_NAME,
  439.                                 GTST_String,    "",
  440.                             TAG_DONE);
  441.  
  442.                             LT_SetAttributes(Handle,GAD_CLEAR,
  443.                                 GA_Disabled,    TRUE,
  444.                             TAG_DONE);
  445.  
  446.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  447.                                 GA_Disabled,    TRUE,
  448.                             TAG_DONE);
  449.  
  450.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  451.                                 GA_Disabled,    TRUE,
  452.                             TAG_DONE);
  453.                         }
  454.                         else
  455.                         {
  456.                             LT_SetAttributes(Handle,GAD_NAME,
  457.                                 GTST_String,    TransferNode -> ln_Name,
  458.                             TAG_DONE);
  459.                         }
  460.                     }
  461.  
  462.                     break;
  463.  
  464.                 case GAD_LIST:
  465.  
  466.                     if(TransferNode = (struct Node *)GetListNode(MsgCode,TransferList))
  467.                     {
  468.                         TransferOffset = MsgCode;
  469.  
  470.                         LT_SetAttributes(Handle,GAD_NAME,
  471.                             GTST_String,    TransferNode -> ln_Name,
  472.                         TAG_DONE);
  473.  
  474.                         LT_SetAttributes(Handle,GAD_REMOVE,
  475.                             GA_Disabled,    FALSE,
  476.                         TAG_DONE);
  477.                     }
  478.  
  479.                     break;
  480.  
  481.                 case GAD_NAME:
  482.  
  483.                     if(TransferNode)
  484.                     {
  485.                         LT_SetAttributes(Handle,GAD_LIST,
  486.                             GTLV_Labels,    ~0,
  487.                         TAG_DONE);
  488.  
  489.                         strcpy(TransferNode -> ln_Name,LT_GetString(Handle,GAD_NAME));
  490.  
  491.                         LT_SetAttributes(Handle,GAD_LIST,
  492.                             GTLV_Labels,    TransferList,
  493.                             GTLV_Selected,    ~0,
  494.                         TAG_DONE);
  495.                     }
  496.                     else
  497.                     {
  498.                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  499.                         {
  500.                             Node -> ln_Name = (STRPTR)(Node + 1);
  501.  
  502.                             strcpy(Node -> ln_Name,LT_GetString(Handle,GAD_NAME));
  503.  
  504.                             LT_SetAttributes(Handle,GAD_LIST,
  505.                                 GTLV_Labels,    ~0,
  506.                             TAG_DONE);
  507.  
  508.                             AddTail(TransferList,Node);
  509.  
  510.                             TransferCount++;
  511.  
  512.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  513.                                 GA_Disabled,    FALSE,
  514.                             TAG_DONE);
  515.  
  516.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  517.                                 GA_Disabled,    FALSE,
  518.                             TAG_DONE);
  519.  
  520.                             LT_SetAttributes(Handle,GAD_CLEAR,
  521.                                 GA_Disabled,    FALSE,
  522.                             TAG_DONE);
  523.  
  524.                             LT_SetAttributes(Handle,GAD_LIST,
  525.                                 GTLV_Labels,        TransferList,
  526.                                 GTLV_Selected,        ~0,
  527.                                 GTLV_MakeVisible,    TransferCount - 1,
  528.                             TAG_DONE);
  529.                         }
  530.                     }
  531.  
  532.                     LT_SetAttributes(Handle,GAD_REMOVE,
  533.                         GA_Disabled,    TRUE,
  534.                     TAG_DONE);
  535.  
  536.                     LT_SetAttributes(Handle,GAD_NAME,
  537.                         GTST_String,    "",
  538.                     TAG_DONE);
  539.  
  540.                     TransferNode    = NULL;
  541.                     TransferOffset    = -1;
  542.  
  543.                     break;
  544.  
  545.                 case GAD_CLEAR:
  546.  
  547.                     LT_SetAttributes(Handle,GAD_LIST,
  548.                         GTLV_Labels,    ~0,
  549.                     TAG_DONE);
  550.  
  551.                     TransferCount    = 0;
  552.                     TransferOffset    = -1;
  553.                     TransferNode    = NULL;
  554.  
  555.                     FreeList(TransferList);
  556.  
  557.                     LT_SetAttributes(Handle,GAD_REMOVE,
  558.                         GA_Disabled,    TRUE,
  559.                     TAG_DONE);
  560.  
  561.                     LT_SetAttributes(Handle,GAD_NAME,
  562.                         GTST_String,    "",
  563.                     TAG_DONE);
  564.  
  565.                     LT_SetAttributes(Handle,GAD_CLEAR,
  566.                         GA_Disabled,    TRUE,
  567.                     TAG_DONE);
  568.  
  569.                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  570.                         GA_Disabled,    TRUE,
  571.                     TAG_DONE);
  572.  
  573.                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  574.                         GA_Disabled,    TRUE,
  575.                     TAG_DONE);
  576.  
  577.                     LT_SetAttributes(Handle,GAD_LIST,
  578.                         GTLV_Labels,    TransferList,
  579.                         GTLV_Selected,    ~0,
  580.                     TAG_DONE);
  581.  
  582.                     break;
  583.  
  584.                 case UPLOAD_BINARY:
  585.                 case UPLOAD_TEXT:
  586.                 case GAD_HIDE:
  587.  
  588.                     Result = MsgGadget -> GadgetID;
  589.                     break;
  590.             }
  591.         }
  592.     }
  593.  
  594.     return(Result);
  595. }
  596.  
  597.     /* QueueClientDestructor(struct DataMsg *Item):
  598.      *
  599.      *    Local msgitem destructor.
  600.      */
  601.  
  602. STATIC VOID __stdargs
  603. QueueClientDestructor(struct DataMsg *Item)
  604. {
  605.     Signal(TransferProcess,1L << TransferSignal);
  606. }
  607.  
  608.     /* QueueEntry(VOID):
  609.      *
  610.      *    The entry point for the queue process.
  611.      */
  612.  
  613. STATIC VOID __saveds
  614. QueueEntry(VOID)
  615. {
  616.     if(TransferList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  617.     {
  618.         if(TransferQueue = CreateMsgQueue(NULL,0))
  619.         {
  620.             struct MsgPort        *AppPort;
  621.             struct AppIcon        *AppIcon;
  622.             struct AppWindow    *AppWindow;
  623.             APTR             OldPtr;
  624.  
  625.             NewList(TransferList);
  626.  
  627.             TransferNode    = NULL;
  628.             TransferOffset    = -1;
  629.  
  630.             if(AppPort = CreateMsgPort())
  631.             {
  632.                 if((TransferSignal = AllocSignal(-1)) != -1)
  633.                 {
  634.                     ULONG             Signals;
  635.                     BOOLEAN             Done = FALSE;
  636.                     LayoutHandle        *Handle;
  637.                     struct Window        *LocalWindow;
  638.                     ULONG             WindowMask,
  639.                                  TransferMask,
  640.                                  ClientMask;
  641.                     struct AppMessage    *AppMessage;
  642.                     struct DiskObject    *LoadedIcon = NULL;
  643.  
  644.                     if(WorkbenchBase && !Config -> TransferConfig -> HideUploadIcon)
  645.                     {
  646.                         if(IconBase)
  647.                         {
  648.                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  649.  
  650.                             strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  651.  
  652.                             if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  653.                                 LoadedIcon = GetDiskObject(LocalBuffer);
  654.  
  655.                             if(!LoadedIcon)
  656.                                 LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  657.                         }
  658.  
  659.                         AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  660.                     }
  661.                     else
  662.                         AppIcon = NULL;
  663.  
  664.                     AppWindow    = NULL;
  665.                     WindowMask    = NULL;
  666.                     Handle        = NULL;
  667.                     LocalWindow    = NULL;
  668.                     TransferMask    = TransferQueue -> SigMask;
  669.                     ClientMask    = (1L << TransferSignal);
  670.  
  671.                     TransferProcess = (struct Process *)FindTask(NULL);
  672.  
  673.                     OldPtr = TransferProcess -> pr_WindowPtr;
  674.  
  675.                     Signal(ThisProcess,SIG_HANDSHAKE);
  676.  
  677.                     do
  678.                     {
  679.                         Signals = Wait(SIG_KILL | SIG_SHOW | SIG_HIDE | SIG_GOAWAY | WindowMask | TransferMask | PORTMASK(AppPort));
  680.  
  681.                         if(Signals & TransferMask)
  682.                         {
  683.                             struct DataMsg *Item;
  684.  
  685.                             while(Item = GetMsgItem(TransferQueue))
  686.                             {
  687.                                 switch(Item -> Type)
  688.                                 {
  689.                                     case TRANSFERMSG_GET_LIST:
  690.  
  691.                                         Item -> Data = NULL;
  692.  
  693.                                         if(TransferList -> lh_Head -> ln_Succ)
  694.                                         {
  695.                                             struct List *List;
  696.  
  697.                                             if(Handle)
  698.                                             {
  699.                                                 LT_SetAttributes(Handle,GAD_LIST,
  700.                                                     GTLV_Labels,    ~0,
  701.                                                 TAG_DONE);
  702.                                             }
  703.  
  704.                                             if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  705.                                             {
  706.                                                 struct Node *Node,*Next;
  707.  
  708.                                                 NewList(List);
  709.  
  710.                                                 for(Node = TransferList -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
  711.                                                 {
  712.                                                     Remove(Node);
  713.  
  714.                                                     AddTail(List,Node);
  715.                                                 }
  716.  
  717.                                                 Item -> Data = (UBYTE *)List;
  718.                                             }
  719.  
  720.                                             if(Handle)
  721.                                             {
  722.                                                 TransferCount = GetListSize(TransferList);
  723.  
  724.                                                 TransferOffset    = -1;
  725.                                                 TransferNode    = NULL;
  726.  
  727.                                                 LT_SetAttributes(Handle,GAD_REMOVE,
  728.                                                     GA_Disabled,    TRUE,
  729.                                                 TAG_DONE);
  730.  
  731.                                                 LT_SetAttributes(Handle,GAD_NAME,
  732.                                                     GTST_String,    "",
  733.                                                 TAG_DONE);
  734.  
  735.                                                 LT_SetAttributes(Handle,GAD_CLEAR,
  736.                                                     GA_Disabled,    !TransferCount,
  737.                                                 TAG_DONE);
  738.  
  739.                                                 LT_SetAttributes(Handle,UPLOAD_BINARY,
  740.                                                     GA_Disabled,    !TransferCount,
  741.                                                 TAG_DONE);
  742.  
  743.                                                 LT_SetAttributes(Handle,UPLOAD_TEXT,
  744.                                                     GA_Disabled,    !TransferCount,
  745.                                                 TAG_DONE);
  746.  
  747.                                                 LT_SetAttributes(Handle,GAD_LIST,
  748.                                                     GTLV_Labels,    TransferList,
  749.                                                 TAG_DONE);
  750.                                             }
  751.                                         }
  752.  
  753.                                         break;
  754.  
  755.                                         // Check to see if there is anything in the list?
  756.  
  757.                                     case TRANSFERMSG_CHECK_LIST:
  758.  
  759.                                         if(TransferList -> lh_Head -> ln_Succ)
  760.                                             Item -> Size = TRUE;
  761.                                         else
  762.                                             Item -> Size = FALSE;
  763.  
  764.                                         break;
  765.  
  766.                                         // Start a file tansfer?
  767.  
  768.                                     case TRANSFERMSG_UPLOAD:
  769.                                     {
  770.                                         UBYTE        Type = Item -> Size;
  771.                                         struct DataMsg    Msg;
  772.  
  773.                                         DeleteMsgItem(Item);
  774.  
  775.                                         Item = NULL;
  776.  
  777.                                         InitMsgItem(&Msg,QueueClientDestructor);
  778.  
  779.                                         Msg . Type = DATAMSGTYPE_UPLOAD;
  780.                                         Msg . Data = (UBYTE *)TransferList;
  781.                                         Msg . Size = Type;
  782.  
  783.                                         if(Handle)
  784.                                         {
  785.                                             LT_SetAttributes(Handle,GAD_LIST,
  786.                                                 GTLV_Labels,    ~0,
  787.                                             TAG_DONE);
  788.  
  789.                                             LT_LockWindow(LocalWindow);
  790.                                         }
  791.  
  792.                                         Forbid();
  793.  
  794.                                         ClrSignal(ClientMask);
  795.  
  796.                                         PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  797.  
  798.                                         Wait(ClientMask);
  799.  
  800.                                         Permit();
  801.  
  802.                                         if(Handle)
  803.                                         {
  804.                                             TransferCount = GetListSize(TransferList);
  805.  
  806.                                             TransferOffset    = -1;
  807.                                             TransferNode    = NULL;
  808.  
  809.                                             LT_SetAttributes(Handle,GAD_REMOVE,
  810.                                                 GA_Disabled,    TRUE,
  811.                                             TAG_DONE);
  812.  
  813.                                             LT_SetAttributes(Handle,GAD_NAME,
  814.                                                 GTST_String,    "",
  815.                                             TAG_DONE);
  816.  
  817.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  818.                                                 GA_Disabled,    !TransferCount,
  819.                                             TAG_DONE);
  820.  
  821.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  822.                                                 GA_Disabled,    !TransferCount,
  823.                                             TAG_DONE);
  824.  
  825.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  826.                                                 GA_Disabled,    !TransferCount,
  827.                                             TAG_DONE);
  828.  
  829.                                             LT_SetAttributes(Handle,GAD_LIST,
  830.                                                 GTLV_Labels,    TransferList,
  831.                                             TAG_DONE);
  832.  
  833.                                             LT_UnlockWindow(LocalWindow);
  834.                                         }
  835.  
  836.                                         break;
  837.                                     }
  838.  
  839.                                         // Show or hide the icon?
  840.  
  841.                                     case TRANSFERMSG_TOGGLE_ICON:
  842.  
  843.                                             // Hide the icon
  844.  
  845.                                         if(Item -> Size)
  846.                                         {
  847.                                             if(AppIcon)
  848.                                             {
  849.                                                 RemoveAppIcon(AppIcon);
  850.  
  851.                                                 AppIcon = NULL;
  852.                                             }
  853.  
  854.                                             if(LoadedIcon)
  855.                                             {
  856.                                                 FreeDiskObject(LoadedIcon);
  857.  
  858.                                                 LoadedIcon = NULL;
  859.                                             }
  860.                                         }
  861.                                         else
  862.                                         {
  863.                                             if(!AppIcon)
  864.                                             {
  865.                                                 if(WorkbenchBase)
  866.                                                 {
  867.                                                     if(IconBase)
  868.                                                     {
  869.                                                         UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  870.  
  871.                                                         strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  872.  
  873.                                                         if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  874.                                                             LoadedIcon = GetDiskObject(LocalBuffer);
  875.  
  876.                                                         if(!LoadedIcon)
  877.                                                             LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  878.                                                     }
  879.  
  880.                                                     AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  881.                                                 }
  882.                                                 else
  883.                                                     AppIcon = NULL;
  884.                                             }
  885.                                         }
  886.  
  887.                                         break;
  888.                                 }
  889.  
  890.                                 DeleteMsgItem(Item);
  891.                             }
  892.                         }
  893.  
  894.                         if(Signals & SIG_HIDE)
  895.                         {
  896.                             if(AppWindow)
  897.                             {
  898.                                 RemoveAppWindow(AppWindow);
  899.  
  900.                                 AppWindow = NULL;
  901.                             }
  902.  
  903.                             if(Handle)
  904.                             {
  905.                                 LT_DeleteHandle(Handle);
  906.  
  907.                                 Handle = NULL;
  908.                             }
  909.  
  910.                             WindowMask    = NULL;
  911.                             LocalWindow    = NULL;
  912.  
  913.                             TransferProcess -> pr_WindowPtr = OldPtr;
  914.  
  915.                             Signal(ThisProcess,SIG_HANDSHAKE);
  916.                         }
  917.  
  918.                         if(Signals & SIG_GOAWAY)
  919.                         {
  920.                             if(Handle)
  921.                             {
  922.                                 if(LocalWindow -> WScreen == Screen)
  923.                                 {
  924.                                     if(AppWindow)
  925.                                     {
  926.                                         RemoveAppWindow(AppWindow);
  927.  
  928.                                         AppWindow = NULL;
  929.                                     }
  930.  
  931.                                     LT_DeleteHandle(Handle);
  932.  
  933.                                     Handle        = NULL;
  934.                                     WindowMask    = NULL;
  935.                                     LocalWindow    = NULL;
  936.  
  937.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  938.                                 }
  939.                             }
  940.  
  941.                             Signal(ThisProcess,SIG_HANDSHAKE);
  942.                         }
  943.  
  944.                         if(Signals & SIG_KILL)
  945.                             break;
  946.  
  947.                         if(Signals & SIG_SHOW)
  948.                         {
  949.                             if(!Handle)
  950.                             {
  951.                                 Forbid();
  952.  
  953.                                 if(Handle = QueuePanel(Window))
  954.                                 {
  955.                                     Permit();
  956.  
  957.                                     if(WorkbenchBase)
  958.                                         AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  959.                                     else
  960.                                         AppWindow = NULL;
  961.  
  962.                                     LocalWindow    = Handle -> Window;
  963.                                     WindowMask    = PORTMASK(LocalWindow -> UserPort);
  964.  
  965.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  966.                                 }
  967.                                 else
  968.                                     Permit();
  969.                             }
  970.  
  971.                             if(Handle)
  972.                                 LT_ShowWindow(Handle,TRUE);
  973.                         }
  974.  
  975.                         if(Signals & WindowMask)
  976.                         {
  977.                             struct DataMsg    Msg;
  978.                             LONG        Type;
  979.  
  980.                             switch(Type = HandleQueueWindow(Handle))
  981.                             {
  982.                                 case GAD_HIDE:
  983.  
  984.                                     if(AppWindow)
  985.                                     {
  986.                                         RemoveAppWindow(AppWindow);
  987.  
  988.                                         AppWindow = NULL;
  989.                                     }
  990.  
  991.                                     if(Handle)
  992.                                     {
  993.                                         LT_DeleteHandle(Handle);
  994.  
  995.                                         Handle = NULL;
  996.                                     }
  997.  
  998.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  999.  
  1000.                                     WindowMask    = NULL;
  1001.                                     LocalWindow    = NULL;
  1002.  
  1003.                                     break;
  1004.  
  1005.                                 case UPLOAD_BINARY:
  1006.                                 case UPLOAD_TEXT:
  1007.  
  1008.                                     InitMsgItem(&Msg,QueueClientDestructor);
  1009.  
  1010.                                     Msg . Type = DATAMSGTYPE_UPLOAD;
  1011.                                     Msg . Data = (UBYTE *)TransferList;
  1012.                                     Msg . Size = Type;
  1013.  
  1014.                                     if(Handle)
  1015.                                     {
  1016.                                         LT_SetAttributes(Handle,GAD_LIST,
  1017.                                             GTLV_Labels,    ~0,
  1018.                                         TAG_DONE);
  1019.  
  1020.                                         LT_LockWindow(LocalWindow);
  1021.                                     }
  1022.  
  1023.                                     Forbid();
  1024.  
  1025.                                     ClrSignal(ClientMask);
  1026.  
  1027.                                     PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1028.  
  1029.                                     Wait(ClientMask);
  1030.  
  1031.                                     Permit();
  1032.  
  1033.                                     if(Handle)
  1034.                                     {
  1035.                                         TransferCount = GetListSize(TransferList);
  1036.  
  1037.                                         TransferOffset    = -1;
  1038.                                         TransferNode    = NULL;
  1039.  
  1040.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  1041.                                             GA_Disabled,    TRUE,
  1042.                                         TAG_DONE);
  1043.  
  1044.                                         LT_SetAttributes(Handle,GAD_NAME,
  1045.                                             GTST_String,    "",
  1046.                                         TAG_DONE);
  1047.  
  1048.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  1049.                                             GA_Disabled,    !TransferCount,
  1050.                                         TAG_DONE);
  1051.  
  1052.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  1053.                                             GA_Disabled,    !TransferCount,
  1054.                                         TAG_DONE);
  1055.  
  1056.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  1057.                                             GA_Disabled,    !TransferCount,
  1058.                                         TAG_DONE);
  1059.  
  1060.                                         LT_SetAttributes(Handle,GAD_LIST,
  1061.                                             GTLV_Labels,    TransferList,
  1062.                                         TAG_DONE);
  1063.  
  1064.                                         LT_UnlockWindow(LocalWindow);
  1065.                                     }
  1066.  
  1067.                                     break;
  1068.                             }
  1069.                         }
  1070.  
  1071.                         if(Signals & PORTMASK(AppPort))
  1072.                         {
  1073.                             while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1074.                             {
  1075.                                 if(AppMessage -> am_Type == AMTYPE_APPWINDOW && Handle)
  1076.                                 {
  1077.                                     UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1078.                                     BPTR    OldDir,FileLock;
  1079.                                     LONG    i;
  1080.  
  1081.                                     TransferProcess -> pr_WindowPtr = (APTR)-1;
  1082.  
  1083.                                     LT_SetAttributes(Handle,GAD_LIST,
  1084.                                         GTLV_Labels,    ~0,
  1085.                                     TAG_DONE);
  1086.  
  1087.                                     for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1088.                                     {
  1089.                                         if(AppMessage -> am_ArgList[i] . wa_Name)
  1090.                                         {
  1091.                                             OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1092.  
  1093.                                             if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1094.                                             {
  1095.                                                 if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1096.                                                 {
  1097.                                                     if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1098.                                                     {
  1099.                                                         struct Node *Node;
  1100.  
  1101.                                                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1102.                                                         {
  1103.                                                             Node -> ln_Name = (STRPTR)(Node + 1);
  1104.  
  1105.                                                             strcpy(Node -> ln_Name,DummyBuffer);
  1106.  
  1107.                                                             AddTail(TransferList,Node);
  1108.  
  1109.                                                             TransferCount++;
  1110.                                                         }
  1111.                                                     }
  1112.  
  1113.                                                     UnLock(FileLock);
  1114.                                                 }
  1115.                                             }
  1116.  
  1117.                                             CurrentDir(OldDir);
  1118.                                         }
  1119.                                     }
  1120.  
  1121.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  1122.  
  1123.                                     LT_SetAttributes(Handle,GAD_LIST,
  1124.                                         GTLV_Labels,    TransferList,
  1125.                                     TAG_DONE);
  1126.  
  1127.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  1128.                                         GA_Disabled,    !TransferCount,
  1129.                                     TAG_DONE);
  1130.  
  1131.                                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  1132.                                         GA_Disabled,    !TransferCount,
  1133.                                     TAG_DONE);
  1134.  
  1135.                                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  1136.                                         GA_Disabled,    !TransferCount,
  1137.                                     TAG_DONE);
  1138.                                 }
  1139.  
  1140.                                 if(AppMessage -> am_Type == AMTYPE_APPICON)
  1141.                                 {
  1142.                                     if(AppMessage -> am_NumArgs)
  1143.                                     {
  1144.                                         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1145.                                         BPTR    OldDir,FileLock;
  1146.                                         LONG    i;
  1147.  
  1148.                                         TransferProcess -> pr_WindowPtr = (APTR)-1;
  1149.  
  1150.                                         if(Handle)
  1151.                                         {
  1152.                                             LT_SetAttributes(Handle,GAD_LIST,
  1153.                                                 GTLV_Labels,    ~0,
  1154.                                             TAG_DONE);
  1155.                                         }
  1156.  
  1157.                                         for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1158.                                         {
  1159.                                             if(AppMessage -> am_ArgList[i] . wa_Name)
  1160.                                             {
  1161.                                                 OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1162.  
  1163.                                                 if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1164.                                                 {
  1165.                                                     if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1166.                                                     {
  1167.                                                         if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1168.                                                         {
  1169.                                                             struct Node *Node;
  1170.  
  1171.                                                             if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1172.                                                             {
  1173.                                                                 Node -> ln_Name = (STRPTR)(Node + 1);
  1174.  
  1175.                                                                 strcpy(Node -> ln_Name,DummyBuffer);
  1176.  
  1177.                                                                 AddTail(TransferList,Node);
  1178.  
  1179.                                                                 TransferCount++;
  1180.                                                             }
  1181.                                                         }
  1182.  
  1183.                                                         UnLock(FileLock);
  1184.                                                     }
  1185.                                                 }
  1186.  
  1187.                                                 CurrentDir(OldDir);
  1188.                                             }
  1189.                                         }
  1190.  
  1191.                                         if(Handle)
  1192.                                         {
  1193.                                             TransferProcess -> pr_WindowPtr = LocalWindow;
  1194.  
  1195.                                             LT_SetAttributes(Handle,GAD_LIST,
  1196.                                                 GTLV_Labels,    TransferList,
  1197.                                             TAG_DONE);
  1198.  
  1199.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  1200.                                                 GA_Disabled,    !TransferCount,
  1201.                                             TAG_DONE);
  1202.  
  1203.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  1204.                                                 GA_Disabled,    !TransferCount,
  1205.                                             TAG_DONE);
  1206.  
  1207.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  1208.                                                 GA_Disabled,    !TransferCount,
  1209.                                             TAG_DONE);
  1210.                                         }
  1211.                                         else
  1212.                                             TransferProcess -> pr_WindowPtr = OldPtr;
  1213.                                     }
  1214.                                     else
  1215.                                     {
  1216.                                         if(!Handle)
  1217.                                         {
  1218.                                             if(Handle = QueuePanel(NULL))
  1219.                                             {
  1220.                                                 AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  1221.  
  1222.                                                 LocalWindow = Handle -> Window;
  1223.  
  1224.                                                 WindowMask = PORTMASK(LocalWindow -> UserPort);
  1225.  
  1226.                                                 TransferProcess -> pr_WindowPtr = LocalWindow;
  1227.                                             }
  1228.                                         }
  1229.                                     }
  1230.                                 }
  1231.  
  1232.                                 ReplyMsg(AppMessage);
  1233.                             }
  1234.                         }
  1235.                     }
  1236.                     while(!Done);
  1237.  
  1238.                     if(AppIcon)
  1239.                         RemoveAppIcon(AppIcon);
  1240.  
  1241.                     if(AppWindow)
  1242.                         RemoveAppWindow(AppWindow);
  1243.  
  1244.                     if(LoadedIcon)
  1245.                         FreeDiskObject(LoadedIcon);
  1246.  
  1247.                     if(Handle)
  1248.                         LT_DeleteHandle(Handle);
  1249.  
  1250.                     while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1251.                         ReplyMsg(AppMessage);
  1252.  
  1253.                     FreeSignal(TransferSignal);
  1254.                 }
  1255.             }
  1256.  
  1257.             DeleteMsgQueue(TransferQueue);
  1258.         }
  1259.  
  1260.         DeleteList(TransferList);
  1261.  
  1262.         TransferList = NULL;
  1263.     }
  1264.  
  1265.     Forbid();
  1266.  
  1267.     TransferProcess = NULL;
  1268.  
  1269.     Signal(ThisProcess,SIG_HANDSHAKE);
  1270. }
  1271.  
  1272.     /* CloseQueueWindow():
  1273.      *
  1274.      *    Close the queue window, wherever it may be.
  1275.      */
  1276.  
  1277. VOID
  1278. CloseQueueWindow()
  1279. {
  1280.     if(TransferProcess)
  1281.     {
  1282.         Forbid();
  1283.  
  1284.         ClrSignal(SIG_HANDSHAKE);
  1285.  
  1286.         Signal(TransferProcess,SIG_GOAWAY);
  1287.  
  1288.         Wait(SIG_HANDSHAKE);
  1289.  
  1290.         Permit();
  1291.     }
  1292. }
  1293.  
  1294.     /* DeleteQueueProcess():
  1295.      *
  1296.      *    Terminate the queue handler process.
  1297.      */
  1298.  
  1299. VOID
  1300. DeleteQueueProcess()
  1301. {
  1302.     if(TransferProcess)
  1303.     {
  1304.         Forbid();
  1305.  
  1306.         ClrSignal(SIG_HANDSHAKE);
  1307.  
  1308.         Signal(TransferProcess,SIG_KILL);
  1309.  
  1310.         Wait(SIG_HANDSHAKE);
  1311.  
  1312.         Permit();
  1313.     }
  1314. }
  1315.  
  1316.     /* CreateQueueProcess():
  1317.      *
  1318.      *    Create the queue handler process, if it's still around
  1319.      *    bring it to the front.
  1320.      */
  1321.  
  1322. BOOLEAN
  1323. CreateQueueProcess()
  1324. {
  1325.     if(!TransferProcess)
  1326.     {
  1327.         Forbid();
  1328.  
  1329.         if(CreateNewProcTags(
  1330.             NP_Entry,    QueueEntry,
  1331.             NP_Name,    "term Upload process",
  1332.             NP_Priority,    SysBase -> ThisTask -> tc_Node . ln_Pri,
  1333.             NP_StackSize,    6144,
  1334.             NP_WindowPtr,    NULL,
  1335.         TAG_DONE))
  1336.         {
  1337.             ClrSignal(SIG_HANDSHAKE);
  1338.  
  1339.             Wait(SIG_HANDSHAKE);
  1340.         }
  1341.  
  1342.         Permit();
  1343.     }
  1344.     else
  1345.         Signal(TransferProcess,SIG_SHOW);
  1346.  
  1347.     return((BOOLEAN)(TransferProcess != NULL));
  1348. }
  1349.  
  1350. STATIC VOID __stdargs
  1351. LocalMsgDestructor(struct DataMsg *Item)
  1352. {
  1353.     Signal(Item -> Client,Item -> Mask);
  1354. }
  1355.  
  1356.     /* GetUploadList():
  1357.      *
  1358.      *    Copy the current upload list and return it.
  1359.      */
  1360.  
  1361. struct List *
  1362. GetUploadList()
  1363. {
  1364.     if(TransferProcess)
  1365.     {
  1366.         BYTE SigBit;
  1367.  
  1368.         if((SigBit = AllocSignal(-1)) != -1)
  1369.         {
  1370.             struct DataMsg Msg;
  1371.  
  1372.             InitMsgItem(&Msg,LocalMsgDestructor);
  1373.  
  1374.             Msg . Type    = TRANSFERMSG_GET_LIST;
  1375.             Msg . Client    = SysBase -> ThisTask;
  1376.             Msg . Mask    = 1L << SigBit;
  1377.  
  1378.             ClrSignal(Msg . Mask);
  1379.  
  1380.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1381.  
  1382.             Wait(Msg . Mask);
  1383.  
  1384.             FreeSignal(SigBit);
  1385.  
  1386.             return((struct List *)Msg . Data);
  1387.         }
  1388.     }
  1389.  
  1390.     return(NULL);
  1391. }
  1392.  
  1393.     /* CheckUpload():
  1394.      *
  1395.      *    Check if there is anything in the upload list.
  1396.      */
  1397.  
  1398. BOOLEAN
  1399. CheckUpload()
  1400. {
  1401.     if(TransferProcess)
  1402.     {
  1403.         BYTE SigBit;
  1404.  
  1405.         if((SigBit = AllocSignal(-1)) != -1)
  1406.         {
  1407.             struct DataMsg Msg;
  1408.  
  1409.             InitMsgItem(&Msg,LocalMsgDestructor);
  1410.  
  1411.             Msg . Type    = TRANSFERMSG_CHECK_LIST;
  1412.             Msg . Client    = SysBase -> ThisTask;
  1413.             Msg . Mask    = 1L << SigBit;
  1414.  
  1415.             ClrSignal(Msg . Mask);
  1416.  
  1417.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1418.  
  1419.             Wait(Msg . Mask);
  1420.  
  1421.             FreeSignal(SigBit);
  1422.  
  1423.             return((BOOLEAN)Msg . Size);
  1424.         }
  1425.     }
  1426.  
  1427.     return(FALSE);
  1428. }
  1429.  
  1430.     /* StartUpload(UBYTE Type):
  1431.      *
  1432.      *    Start an upload the standard way.
  1433.      */
  1434.  
  1435. VOID __regargs
  1436. StartUpload(UBYTE Type)
  1437. {
  1438.     if(TransferProcess)
  1439.     {
  1440.         BYTE SigBit;
  1441.  
  1442.         if((SigBit = AllocSignal(-1)) != -1)
  1443.         {
  1444.             struct DataMsg Msg;
  1445.  
  1446.             SetQueueDiscard(SpecialQueue,FALSE);
  1447.  
  1448.             InitMsgItem(&Msg,LocalMsgDestructor);
  1449.  
  1450.             Msg . Type    = TRANSFERMSG_UPLOAD;
  1451.             Msg . Size    = Type;
  1452.             Msg . Client    = SysBase -> ThisTask;
  1453.             Msg . Mask    = 1L << SigBit;
  1454.  
  1455.             ClrSignal(Msg . Mask);
  1456.  
  1457.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1458.  
  1459.             Wait(Msg . Mask);
  1460.  
  1461.             FreeSignal(SigBit);
  1462.         }
  1463.     }
  1464. }
  1465.  
  1466.     /* ToggleUploadQueueIcon():
  1467.      *
  1468.      *    Turn the upload queue appicon on or off.
  1469.      */
  1470.  
  1471. VOID __regargs
  1472. ToggleUploadQueueIcon(BOOL Mode)
  1473. {
  1474.     if(TransferProcess)
  1475.     {
  1476.         BYTE SigBit;
  1477.  
  1478.         if((SigBit = AllocSignal(-1)) != -1)
  1479.         {
  1480.             struct DataMsg Msg;
  1481.  
  1482.             InitMsgItem(&Msg,LocalMsgDestructor);
  1483.  
  1484.             Msg . Type    = TRANSFERMSG_TOGGLE_ICON;
  1485.             Msg . Size    = Mode;
  1486.             Msg . Client    = SysBase -> ThisTask;
  1487.             Msg . Mask    = 1L << SigBit;
  1488.  
  1489.             ClrSignal(Msg . Mask);
  1490.  
  1491.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1492.  
  1493.             Wait(Msg . Mask);
  1494.  
  1495.             FreeSignal(SigBit);
  1496.         }
  1497.     }
  1498. }
  1499.